DecimalFormat

class U_I18N_API DecimalFormat : public NumberFormat

Concrete class for formatting decimal numbers, allowing a variety of parameters, and localization to Western, Arabic, or Indic numbers

Inheritance:

Public Fields
static const UnicodeString fgNumberPatterns: The resource tags we use to retrieve decimal format data from locale resource bundles

Public Methods
DecimalFormat(UErrorCode& status): Create a DecimalFormat using the default pattern and symbols for the default locale
DecimalFormat(const UnicodeString& pattern, UErrorCode& status): Create a DecimalFormat from the given pattern and the symbols for the default locale
DecimalFormat( const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt, UErrorCode& status): Create a DecimalFormat from the given pattern and symbols
DecimalFormat( const UnicodeString& pattern, const DecimalFormatSymbols& symbols, UErrorCode& status): Create a DecimalFormat from the given pattern and symbols
DecimalFormat(const DecimalFormat& source): Copy constructor
DecimalFormat& operator=(const DecimalFormat& rhs): Assignment operator
virtual ~DecimalFormat(): Destructor
virtual Format* clone(void) const: Clone this Format object polymorphically
virtual bool_t operator==(const Format& other) const: Return true if the given Format objects are semantically equal
virtual UnicodeString& format(double number, UnicodeString& toAppendTo, FieldPosition& pos) const: Format a double or long number using base-10 representation
UnicodeString& format(const Formattable& obj, UnicodeString& result, UErrorCode& status) const: Redeclared NumberFormat method
UnicodeString& format(double number, UnicodeString& output) const: Redeclared NumberFormat method
UnicodeString& format(int32_t number, UnicodeString& output) const: Redeclared NumberFormat method
virtual void parse(const UnicodeString& text, Formattable& result, ParsePosition& parsePosition) const: Parse the given string using this object's choices
virtual const DecimalFormatSymbols* getDecimalFormatSymbols(void) const: Returns the decimal format symbols, which is generally not changed by the programmer or user
virtual void adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt): Sets the decimal format symbols, which is generally not changed by the programmer or user
virtual void setDecimalFormatSymbols(const DecimalFormatSymbols& symbols): Sets the decimal format symbols, which is generally not changed by the programmer or user
UnicodeString& getPositivePrefix(UnicodeString& result) const: Get the positive prefix
virtual void setPositivePrefix(const UnicodeString& newValue): Set the positive prefix
UnicodeString& getNegativePrefix(UnicodeString& result) const: Get the negative prefix
virtual void setNegativePrefix(const UnicodeString& newValue): Set the negative prefix
UnicodeString& getPositiveSuffix(UnicodeString& result) const: Get the positive suffix
virtual void setPositiveSuffix(const UnicodeString& newValue): Set the positive suffix
UnicodeString& getNegativeSuffix(UnicodeString& result) const: Get the negative suffix
virtual void setNegativeSuffix(const UnicodeString& newValue): Set the positive suffix
int32_t getMultiplier(void) const: Get the multiplier for use in percent, permill, etc
virtual void setMultiplier(int32_t newValue): Set the multiplier for use in percent, permill, etc
virtual double getRoundingIncrement(void): Get the rounding increment
virtual void setRoundingIncrement(double newValue): Set the rounding increment
virtual ERoundingMode getRoundingMode(void): Get the rounding mode
virtual void setRoundingMode(ERoundingMode roundingMode): Set the rounding mode
virtual int32_t getFormatWidth(void): Get the width to which the output of format() is padded
virtual void setFormatWidth(int32_t width): Set the width to which the output of format() is padded
virtual UChar getPadCharacter(void): Get the character used to pad to the format width
virtual void setPadCharacter(UChar padChar): Set the character used to pad to the format width
virtual EPadPosition getPadPosition(void): Get the position at which padding will take place
virtual void setPadPosition(EPadPosition padPos): NEW Set the position at which padding will take place
virtual bool_t isScientificNotation(void): Return whether or not scientific notation is used
virtual void setScientificNotation(bool_t useScientific): Set whether or not scientific notation is used
virtual int8_t getMinimumExponentDigits(void): Return the minimum exponent digits that will be shown
virtual void setMinimumExponentDigits(int8_t minExpDig): Set the minimum exponent digits that will be shown
virtual bool_t isExponentSignAlwaysShown(void): Return whether the exponent sign is always shown
virtual void setExponentSignAlwaysShown(bool_t expSignAlways): Set whether the exponent sign is always shown
int32_t getGroupingSize(void) const: Return the grouping size
virtual void setGroupingSize(int32_t newValue): Set the grouping size
bool_t isDecimalSeparatorAlwaysShown(void) const: Allows you to get the behavior of the decimal separator with integers
virtual void setDecimalSeparatorAlwaysShown(bool_t newValue): Allows you to set the behavior of the decimal separator with integers
virtual UnicodeString& toPattern(UnicodeString& result) const: Synthesizes a pattern string that represents the current state of this Format object
virtual UnicodeString& toLocalizedPattern(UnicodeString& result) const: Synthesizes a localized pattern string that represents the current state of this Format object
virtual void applyPattern(const UnicodeString& pattern, UErrorCode& status): Apply the given pattern to this Format object
virtual void applyLocalizedPattern(const UnicodeString& pattern, UErrorCode& status): Apply the given pattern to this Format object
virtual void setMaximumIntegerDigits(int32_t newValue): Sets the maximum number of digits allowed in the integer portion of a number
virtual void setMinimumIntegerDigits(int32_t newValue): Sets the minimum number of digits allowed in the integer portion of a number
virtual void setMaximumFractionDigits(int32_t newValue): Sets the maximum number of digits allowed in the fraction portion of a number
virtual void setMinimumFractionDigits(int32_t newValue): Sets the minimum number of digits allowed in the fraction portion of a number
static UClassID getStaticClassID(void): Return the class ID for this class
virtual UClassID getDynamicClassID(void) const: Returns a unique class ID POLYMORPHICALLY

Inherited from NumberFormat:

Public Classes
enum EAlignmentFields

INTEGER_FIELD
These constants are provided for backwards compatibility only, and are deprecated

Public Methods
virtual void parseObject(const UnicodeString& source, Formattable& result, ParsePosition& parse_pos) const
bool_t isParseIntegerOnly(void) const
virtual void setParseIntegerOnly(bool_t value)
static NumberFormat* createInstance(UErrorCode&)
static NumberFormat* createInstance(const Locale& inLocale, UErrorCode&)
static NumberFormat* createCurrencyInstance(UErrorCode&)
static NumberFormat* createCurrencyInstance(const Locale& inLocale, UErrorCode&)
static NumberFormat* createPercentInstance(UErrorCode&)
static NumberFormat* createPercentInstance(const Locale& inLocale, UErrorCode&)
static NumberFormat* createScientificInstance(UErrorCode&)
static NumberFormat* createScientificInstance(const Locale& inLocale, UErrorCode&)
static const Locale* getAvailableLocales(int32_t& count)
bool_t isGroupingUsed(void) const
virtual void setGroupingUsed(bool_t newValue)
int32_t getMaximumIntegerDigits(void) const
int32_t getMinimumIntegerDigits(void) const
int32_t getMaximumFractionDigits(void) const
int32_t getMinimumFractionDigits(void) const

Inherited from Format:

Public Methods
bool_t operator!=(const Format& other) const

Documentation

Concrete class for formatting decimal numbers, allowing a variety of parameters, and localization to Western, Arabic, or Indic numbers.
Normally, you get the proper NumberFormat for a specific locale (including the default locale) using the NumberFormat factory methods, rather than constructing a DecimalNumberFormat directly.
Either the prefixes or the suffixes must be different for the parse to distinguish positive from negative. Parsing will be unreliable if the digits, thousands or decimal separators are the same, or if any of them occur in the prefixes or suffixes.
[Special cases:]
NaN is formatted as a single character, typically \\uFFFD.
+/-Infinity is formatted as a single character, typically \\u221E, plus the positive and negative pre/suffixes.
Note: this class is designed for common users; for very large or small numbers, use a format that can express exponential values.
[Example:]
.    // normally we would have a GUI with a menu for this
.    int32_t locCount;
.    const Locale* locales = NumberFormat::getAvailableLocales(locCount);
.    if (locCount > 12) locCount = 12;  //limit output
.
.    double myNumber = -1234.56;
.    UErrorCode success = U_ZERO_ERROR;
.    NumberFormat* form; //= NumberFormat::createInstance(success);
.
.    // just for fun, we print out a number with the locale number, currency
.    // and percent format for each locale we can.
.    UnicodeString countryName;
.    UnicodeString displayName;
.    UnicodeString str;
.    UnicodeString pattern;
.    Formattable fmtable;
.    for (int32_t j = 0; j < 3; ++j) {
.        cout << endl << "FORMAT " << j << endl;
.        for (int32_t i = 0; i < locCount; ++i) {
.            if (locales[i].getCountry(countryName).size() == 0) {
.                // skip language-only
.                continue;
.            }
.            switch (j) {
.            default:
.                form = NumberFormat::createInstance(locales[i], success ); break;
.            case 1:
.                form = NumberFormat::createCurrencyInstance(locales[i], success ); break;
.            case 0:
.                form = NumberFormat::createPercentInstance(locales[i], success ); break;
.            }
.            if (form) {
.                str.remove();
.                pattern = ((DecimalFormat*)form)->toPattern(pattern);
.                cout << locales[i].getDisplayName(displayName) << ": " << pattern;
.                cout << "  ->  " << form->format(myNumber,str) << endl;
.                form->parse(form->format(myNumber,str), fmtable, success);
.                //cout << "   parsed: " << fmtable << endl;
.                delete form;  
.            }
.        }
.    }
[The following shows the structure of the pattern.]
.    pattern    := subpattern{;subpattern}
.    subpattern := {prefix}integer{.fraction}{suffix}
.    
.    prefix     := '\\u0000'..'\\uFFFD' - specialCharacters
.    suffix     := '\\u0000'..'\\uFFFD' - specialCharacters
.    integer    := '#'* '0'* '0'
.    fraction   := '0'* '#'*

Notation:
.    X*       0 or more instances of X
.    (X | Y)  either X or Y.
.    X..Y     any character from X up to Y, inclusive.
.    S - T    characters in S, except those in T
The first subpattern is for positive numbers. The second (optional) subpattern is used for negative numbers. (In both cases, ',' can occur inside the integer portion--it is just too messy to indicate in BNF.) For the second subpattern, only the PREFIX and SUFFIX are noted; other attributes are taken only from the first subpattern.
Here are the special characters used in the parts of the subpattern, with notes on their usage.
.    Symbol   Meaning
.      0      a digit, showing up a zero if it is zero
.      #      a digit, supressed if zero
.      .      placeholder for decimal separator
.      ,      placeholder for grouping separator.
.      E      separates mantissa and exponent for exponential formats.
.      ;      separates formats.
.      -      default negative prefix.
.      %      multiply by 100 and show as percentage
.      \u2030 multiply by 1000 and show as per mille
.      \u00A4 currency sign; replaced by currency symbol; if
.             doubled, replaced by international currency symbol.
.             If present in a pattern, the monetary decimal separator
.             is used instead of the decimal separator.
.      X      any other characters can be used in the prefix or suffix
.      '      used to quote special characters in a prefix or suffix.
[Notes]
If there is no explicit negative subpattern, - is prefixed to the positive form. That is, "0.00" alone is equivalent to "0.00;-0.00".
Illegal formats, such as "#.#.#" in the same format, will cause a failing UErrorCode to be returned.
The grouping separator is commonly used for thousands, but in some countries for ten-thousands. The interval is a constant number of digits between the grouping characters, such as 100,000,000 or 1,0000,0000. If you supply a pattern with multiple grouping characters, the interval between the last one and the end of the integer is the one that is used. So "#,##,###,####" == "######,####" == "##,####,####".
This class only handles localized digits where the 10 digits are contiguous in Unicode, from 0 to 9. Other digits sets (such as superscripts) would need a different subclass.

DecimalFormat(UErrorCode& status)

Create a DecimalFormat using the default pattern and symbols for the default locale. This is a convenient way to obtain a DecimalFormat when internationalization is not the main concern.

To obtain standard formats for a given locale, use the factory methods on NumberFormat such as getNumberInstance. These factories will return the most appropriate sub-class of NumberFormat for a given locale.

Parameters:: status - Output param set to success/failure code. If the pattern is invalid this will be set to a failure code.

DecimalFormat(const UnicodeString& pattern, UErrorCode& status)

Create a DecimalFormat from the given pattern and the symbols for the default locale. This is a convenient way to obtain a DecimalFormat when internationalization is not the main concern.

Parameters:: pattern - A non-localized pattern string.
status - Output param set to success/failure code. If the pattern is invalid this will be set to a failure code.

DecimalFormat( const UnicodeString& pattern, DecimalFormatSymbols* symbolsToAdopt, UErrorCode& status)

Create a DecimalFormat from the given pattern and symbols. Use this constructor when you need to completely customize the behavior of the format.

To obtain standard formats for a given locale, use the factory methods on NumberFormat such as getInstance or getCurrencyInstance. If you need only minor adjustments to a standard format, you can modify the format returned by a NumberFormat factory method.

Parameters:: pattern - a non-localized pattern string
symbolsToAdopt - the set of symbols to be used. The caller should not delete this object after making this call.
status - Output param set to success/failure code. If the pattern is invalid this will be set to a failure code.

DecimalFormat( const UnicodeString& pattern, const DecimalFormatSymbols& symbols, UErrorCode& status)

Create a DecimalFormat from the given pattern and symbols. Use this constructor when you need to completely customize the behavior of the format.

Parameters:: pattern - a non-localized pattern string
symbols - the set of symbols to be used
status - Output param set to success/failure code. If the pattern is invalid this will be set to a failure code.

DecimalFormat(const DecimalFormat& source)

Copy constructor

DecimalFormat& operator=(const DecimalFormat& rhs)

Assignment operator

virtual ~DecimalFormat()

Destructor

virtual Format* clone(void) const

Clone this Format object polymorphically. The caller owns the result and should delete it when done.

virtual bool_t operator==(const Format& other) const

Return true if the given Format objects are semantically equal. Objects of different subclasses are considered unequal.

virtual UnicodeString& format(double number, UnicodeString& toAppendTo, FieldPosition& pos) const

Format a double or long number using base-10 representation.

Returns:: A reference to 'toAppendTo'.
Parameters:: number - The value to be formatted.
toAppendTo - The string to append the formatted string to. This is an output parameter.
pos - On input: an alignment field, if desired. On output: the offsets of the alignment field.

UnicodeString& format(const Formattable& obj, UnicodeString& result, UErrorCode& status) const

Redeclared NumberFormat method

UnicodeString& format(double number, UnicodeString& output) const

Redeclared NumberFormat method

UnicodeString& format(int32_t number, UnicodeString& output) const

Redeclared NumberFormat method

virtual void parse(const UnicodeString& text, Formattable& result, ParsePosition& parsePosition) const

Parse the given string using this object's choices. The method does string comparisons to try to find an optimal match. If no object can be parsed, index is unchanged, and NULL is returned.

Parameters:: text - The text to be parsed.
result - Formattable to be set to the parse result. If parse fails, return contents are undefined.
parsePosition - The position to start parsing at on input. On output, moved to after the last successfully parse character. On parse failure, does not change.

virtual const DecimalFormatSymbols* getDecimalFormatSymbols(void) const

Returns the decimal format symbols, which is generally not changed by the programmer or user

Returns:: desired DecimalFormatSymbols
See Also:: DecimalFormatSymbols

virtual void adoptDecimalFormatSymbols(DecimalFormatSymbols* symbolsToAdopt)

Sets the decimal format symbols, which is generally not changed by the programmer or user

Parameters:: symbolsToAdopt - DecimalFormatSymbols to be adopted.

virtual void setDecimalFormatSymbols(const DecimalFormatSymbols& symbols)

Sets the decimal format symbols, which is generally not changed by the programmer or user

Parameters:: symbols - DecimalFormatSymbols.

UnicodeString& getPositivePrefix(UnicodeString& result) const

Get the positive prefix. Examples: +123, $123, sFr123

virtual void setPositivePrefix(const UnicodeString& newValue)

Set the positive prefix. Examples: +123, $123, sFr123

UnicodeString& getNegativePrefix(UnicodeString& result) const

Get the negative prefix. Examples: -123, ($123) (with negative suffix), sFr-123

virtual void setNegativePrefix(const UnicodeString& newValue)

Set the negative prefix. Examples: -123, ($123) (with negative suffix), sFr-123

UnicodeString& getPositiveSuffix(UnicodeString& result) const

Get the positive suffix. Example: 123%

virtual void setPositiveSuffix(const UnicodeString& newValue)

Set the positive suffix. Example: 123%

UnicodeString& getNegativeSuffix(UnicodeString& result) const

Get the negative suffix. Examples: -123%, ($123) (with positive suffixes)

virtual void setNegativeSuffix(const UnicodeString& newValue)

Set the positive suffix. Examples: 123%

int32_t getMultiplier(void) const

Get the multiplier for use in percent, permill, etc. For a percentage, set the suffixes to have "%" and the multiplier to be 100. (For Arabic, use arabic percent symbol). For a permill, set the suffixes to have "\u2031" and the multiplier to be 1000. Examples: with 100, 1.23 -> "123", and "123" -> 1.23

virtual void setMultiplier(int32_t newValue)

Set the multiplier for use in percent, permill, etc. For a percentage, set the suffixes to have "%" and the multiplier to be 100. (For Arabic, use arabic percent symbol). For a permill, set the suffixes to have "\u2031" and the multiplier to be 1000. Examples: with 100, 1.23 -> "123", and "123" -> 1.23

virtual double getRoundingIncrement(void)

Get the rounding increment

Returns:: A positive rounding increment, or 0.0 if rounding is not in effect.
See Also:: setRoundingIncrement
getRoundingMode
setRoundingMode

virtual void setRoundingIncrement(double newValue)

Set the rounding increment. This method also controls whether rounding is enabled.

Parameters:: newValue - A positive rounding increment, or 0.0 to disable rounding. Negative increments are equivalent to 0.0.
See Also:: getRoundingIncrement
getRoundingMode
setRoundingMode

virtual ERoundingMode getRoundingMode(void)

Get the rounding mode

Returns:: A rounding mode
See Also:: setRoundingIncrement
getRoundingIncrement
setRoundingMode

virtual void setRoundingMode(ERoundingMode roundingMode)

Set the rounding mode. This has no effect unless the rounding increment is greater than zero.

Parameters:: roundingMode - A rounding mode
See Also:: setRoundingIncrement
getRoundingIncrement
getRoundingMode

virtual int32_t getFormatWidth(void)

Get the width to which the output of format() is padded

Returns:: the format width, or zero if no padding is in effect
See Also:: setFormatWidth
getPadCharacter
setPadCharacter
getPadPosition
setPadPosition

virtual void setFormatWidth(int32_t width)

Set the width to which the output of format() is padded. This method also controls whether padding is enabled.

Parameters:: width - the width to which to pad the result of format(), or zero to disable padding. A negative width is equivalent to 0.
See Also:: getFormatWidth
getPadCharacter
setPadCharacter
getPadPosition
setPadPosition

virtual UChar getPadCharacter(void)

Get the character used to pad to the format width. The default is ' '.

Returns:: the pad character
See Also:: setFormatWidth
getFormatWidth
setPadCharacter
getPadPosition
setPadPosition

virtual void setPadCharacter(UChar padChar)

Set the character used to pad to the format width. This has no effect unless padding is enabled.

Parameters:: padChar - the pad character
See Also:: setFormatWidth
getFormatWidth
getPadCharacter
getPadPosition
setPadPosition

virtual EPadPosition getPadPosition(void)

Get the position at which padding will take place. This is the location at which padding will be inserted if the result of format() is shorter than the format width.

Returns:: the pad position, one of kPadBeforePrefix, kPadAfterPrefix, kPadBeforeSuffix, or kPadAfterSuffix.
See Also:: setFormatWidth
getFormatWidth
setPadCharacter
getPadCharacter
setPadPosition
kPadBeforePrefix
kPadAfterPrefix
kPadBeforeSuffix
kPadAfterSuffix

virtual void setPadPosition(EPadPosition padPos)

NEW Set the position at which padding will take place. This is the location at which padding will be inserted if the result of format() is shorter than the format width. This has no effect unless padding is enabled.

Parameters:: padPos - the pad position, one of kPadBeforePrefix, kPadAfterPrefix, kPadBeforeSuffix, or kPadAfterSuffix.
See Also:: setFormatWidth
getFormatWidth
setPadCharacter
getPadCharacter
getPadPosition
kPadBeforePrefix
kPadAfterPrefix
kPadBeforeSuffix
kPadAfterSuffix

virtual bool_t isScientificNotation(void)

Return whether or not scientific notation is used

Returns:: TRUE if this object formats and parses scientific notation
See Also:: setScientificNotation
getMinimumExponentDigits
setMinimumExponentDigits
isExponentSignAlwaysShown
setExponentSignAlwaysShown

virtual void setScientificNotation(bool_t useScientific)

Set whether or not scientific notation is used

Parameters:: useScientific - TRUE if this object formats and parses scientific notation
See Also:: isScientificNotation
getMinimumExponentDigits
setMinimumExponentDigits
isExponentSignAlwaysShown
setExponentSignAlwaysShown

virtual int8_t getMinimumExponentDigits(void)

Return the minimum exponent digits that will be shown

Returns:: the minimum exponent digits that will be shown
See Also:: setScientificNotation
isScientificNotation
setMinimumExponentDigits
isExponentSignAlwaysShown
setExponentSignAlwaysShown

virtual void setMinimumExponentDigits(int8_t minExpDig)

Set the minimum exponent digits that will be shown. This has no effect unless scientific notation is in use.

Parameters:: minExpDig - a value >= 1 indicating the fewest exponent digits that will be shown. Values less than 1 will be treated as 1.
See Also:: setScientificNotation
isScientificNotation
getMinimumExponentDigits
isExponentSignAlwaysShown
setExponentSignAlwaysShown

virtual bool_t isExponentSignAlwaysShown(void)

Return whether the exponent sign is always shown

Returns:: TRUE if the exponent is always prefixed with either the localized minus sign or the localized plus sign, false if only negative exponents are prefixed with the localized minus sign.
See Also:: setScientificNotation
isScientificNotation
setMinimumExponentDigits
getMinimumExponentDigits
setExponentSignAlwaysShown

virtual void setExponentSignAlwaysShown(bool_t expSignAlways)

Set whether the exponent sign is always shown. This has no effect unless scientific notation is in use.

Parameters:: expSignAlways - TRUE if the exponent is always prefixed with either the localized minus sign or the localized plus sign, false if only negative exponents are prefixed with the localized minus sign.
See Also:: setScientificNotation
isScientificNotation
setMinimumExponentDigits
getMinimumExponentDigits
isExponentSignAlwaysShown

int32_t getGroupingSize(void) const

Return the grouping size. Grouping size is the number of digits between grouping separators in the integer portion of a number. For example, in the number "123,456.78", the grouping size is 3.

See Also:: setGroupingSize
NumberFormat::isGroupingUsed
DecimalFormatSymbols::getGroupingSeparator

virtual void setGroupingSize(int32_t newValue)

Set the grouping size. Grouping size is the number of digits between grouping separators in the integer portion of a number. For example, in the number "123,456.78", the grouping size is 3.

See Also:: getGroupingSize
NumberFormat::setGroupingUsed
DecimalFormatSymbols::setGroupingSeparator

bool_t isDecimalSeparatorAlwaysShown(void) const

Allows you to get the behavior of the decimal separator with integers. (The decimal separator will always appear with decimals.) Example: Decimal ON: 12345 -> 12345.; OFF: 12345 -> 12345

virtual void setDecimalSeparatorAlwaysShown(bool_t newValue)

Allows you to set the behavior of the decimal separator with integers. (The decimal separator will always appear with decimals.) Example: Decimal ON: 12345 -> 12345.; OFF: 12345 -> 12345

virtual UnicodeString& toPattern(UnicodeString& result) const

Synthesizes a pattern string that represents the current state of this Format object

See Also:: applyPattern

virtual UnicodeString& toLocalizedPattern(UnicodeString& result) const

Synthesizes a localized pattern string that represents the current state of this Format object.

See Also:: applyPattern

virtual void applyPattern(const UnicodeString& pattern, UErrorCode& status)

Apply the given pattern to this Format object. A pattern is a short-hand specification for the various formatting properties. These properties can also be changed individually through the various setter methods.

There is no limit to integer digits are set by this routine, since that is the typical end-user desire; use setMaximumInteger if you want to set a real value. For negative numbers, use a second pattern, separated by a semicolon

.      Example "#,#00.0#" -> 1,234.56

This means a minimum of 2 integer digits, 1 fraction digit, and a maximum of 2 fraction digits.

.      Example: "#,#00.0#;(#,#00.0#)" for negatives in parantheses.

In negative patterns, the minimum and maximum counts are ignored; these are presumed to be set in the positive pattern.

Parameters:: pattern - The pattern to be applied.
status - Output param set to success/failure code on exit. If the pattern is invalid, this will be set to a failure result.

virtual void applyLocalizedPattern(const UnicodeString& pattern, UErrorCode& status)

Apply the given pattern to this Format object. The pattern is assumed to be in a localized notation. A pattern is a short-hand specification for the various formatting properties. These properties can also be changed individually through the various setter methods.

.      Example "#,#00.0#" -> 1,234.56

This means a minimum of 2 integer digits, 1 fraction digit, and a maximum of 2 fraction digits. Example: "#,#00.0#;(#,#00.0#)" for negatives in parantheses. In negative patterns, the minimum and maximum counts are ignored; these are presumed to be set in the positive pattern.

Parameters:: pattern - The localized pattern to be applied.
status - Output param set to success/failure code on exit. If the pattern is invalid, this will be set to a failure result.

virtual void setMaximumIntegerDigits(int32_t newValue)

Sets the maximum number of digits allowed in the integer portion of a number. This override limits the integer digit count to 309.

See Also:: setMaximumIntegerDigits

virtual void setMinimumIntegerDigits(int32_t newValue)

Sets the minimum number of digits allowed in the integer portion of a number. This override limits the integer digit count to 309.

See Also:: setMinimumIntegerDigits

virtual void setMaximumFractionDigits(int32_t newValue)

Sets the maximum number of digits allowed in the fraction portion of a number. This override limits the fraction digit count to 340.

See Also:: setMaximumFractionDigits

virtual void setMinimumFractionDigits(int32_t newValue)

Sets the minimum number of digits allowed in the fraction portion of a number. This override limits the fraction digit count to 340.

See Also:: setMinimumFractionDigits

static const UnicodeString fgNumberPatterns

The resource tags we use to retrieve decimal format data from locale resource bundles

static UClassID getStaticClassID(void)

Return the class ID for this class. This is useful only for comparing to a return value from getDynamicClassID(). For example:

.      Base* polymorphic_pointer = createPolymorphicObject();
.      if (polymorphic_pointer->getDynamicClassID() ==
.          Derived::getStaticClassID()) ...

Returns:: The class ID for all objects of this class.

virtual UClassID getDynamicClassID(void) const

Returns a unique class ID POLYMORPHICALLY. Pure virtual override. This method is to implement a simple version of RTTI, since not all C++ compilers support genuine RTTI. Polymorphic operator==() and clone() methods call this method.

Returns:: The class ID for this object. All objects of a given class have the same class ID. Objects of other classes have different class IDs.

This class has no child classes.

alphabetic index hierarchy of classes

this page has been generated automatically by doc++

(c)opyright by Malte Zöckler, Roland Wunderling
contact: doc++@zib.de

class U_I18N_API DecimalFormat : public NumberFormat

Inheritance:

Public Fields

Public Methods

Inherited from NumberFormat:

Public Classes

Public Methods

Inherited from Format:

Public Methods

Documentation